package com.ahuzdw.com;

import java.util.ArrayList;
import java.util.Arrays;

/**
 * Author: Zhang Dongwei
 * Date: 2021/12/14 21:32
 *
 * 给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。
 *
 * 如果反转后整数超过 32 位的有符号整数的范围 [−231,  231 − 1] ，就返回 0。
 *
 * 假设环境不允许存储 64 位整数（有符号或无符号）。
 *
 * 来源：力扣（LeetCode）
 * 链接：https://leetcode-cn.com/problems/reverse-integer
 * 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
 */
public class _7_Reverse {
    public static void main(String[] args) {
        Solution4 solution = new _7_Reverse().new Solution4();
        long ans = solution.reverse(1534236469);
        System.out.println(ans);
    }

    // 自己写的，效率低，冗余，而且使用了long，理论是不能使用
    static class Solution {
        public int reverse(int x) {
            long x1 = (int)x;
            String b = ""+x;
            int lb = b.length();
            if(x1<0){
                lb = lb-1;
            }
            long ans=0;
            int i=0;
            int[] a = new int[lb];
//            ArrayList<Integer> a = new ArrayList<Integer>();
            while (x1!=0){
                a[i] = (int) (x1%10);
                x1 = x1/10;
                System.out.println(a[i]);
                i+=1;
            }
            System.out.println(Arrays.toString(a));
            int l = a.length;
            for(int j=0;j<l;j++){
                System.out.println(a[j]);
                ans = ans + a[j] * (long)Math.pow(10, l-j-1);
            }
            if(ans<=-(long)Math.pow(2,31)||ans>=(long)Math.pow(2,31)-1){
                return 0;
            }
            return (int) ans;
        }
    }

    // 虽然时间很快，但是内存依然很大，而且使用了long
    static class Solution1 {
        public int reverse(int x) {
            long n = 0;
            while (x != 0) {
                n = n * 10 + x % 10;
                x = x / 10;
            }
            return (int) n == n ? (int) n : 0;
        }
    }

    // 时间较快，符合题意
    class Solution2 {
        public int reverse(int x) {
            String xString = Integer.toString(x);
            System.out.println(xString);
            System.out.println(xString.getClass().toString());
            String string = xString;
            int flag = 1;
            if (x < 0) {
                flag = -1;
                string = xString.substring(1);
            }
            try {
                return Integer.valueOf((new StringBuilder(string)).reverse().toString()) * flag;
            }catch (Exception e){
                return 0;
            }
        }
    }
//  超过32位，报错
    class Solution3 {
        public int reverse(int x) {
            String xString = Integer.toString(x);
            System.out.println(xString);
            System.out.println(xString.getClass().toString());
            String string = xString;
            int flag = 1;
            if (x < 0) {
                flag = -1;
                string = xString.substring(1);
            }
            // return Integer.parseInt((new StringBuilder(string)).reverse().toString()) * flag;
            try {
                return Integer.parseInt((new StringBuilder(string)).reverse().toString()) * flag;
            }catch (Exception e){
                return 0;
            }
        }
    }

    class Solution4{
        public int reverse(int x){
            String xstring = Integer.toString(x);
            String string = xstring;
            int flag = 1;
            if(x<0){
                flag = -1;
                string = string.substring(1);
            }
            try{
                return Integer.parseInt((new StringBuffer(string)).reverse().toString()) * flag;

            }catch (Exception e){
                return 0;
            }
        }
    }
}
